/**
* Universidade de Brasilia
* 2013.1
* Trabalho de Programacao Orientada a Objetos
* Professor: Fernando Chacon
* Alunos
*   Lucas Lo Ami Alvino Silva - 09/0009886
*   Leonardo de Sousa Melo    - 08/34220
*
* @author Leonardo de Sousa Melo
*/

#ifndef TESTE_H
#define TESTE_H


#include "UnitTest++.h"
#include "../include/TiposBasicos.h"

//!Classe Teste que reliza todas as execuções testando os domínios
class Teste
{
    private:
    public:
        //!Atributo que pega o retorno dos metodos get das classes teste
        std::string input;
        Teste() {}
        virtual ~Teste(){}
        //!Metodo que chama os metodos get das classes teste
        void RunTestes();
};

//!Classe utilizada para testar o dominio Nome
class TesteNome
{
    private:
        //!atributos utilizados para armazenar dados validos ou invalidos
        std::string nomeValido, nomeInvalido;
    public:
        //!setup da classe
        TesteNome() {
            nomeValido = "Leonardo";
            nomeInvalido = "";
        }
        //!tearDown da classe
        virtual ~TesteNome(){}
        std::string getTesteNomeValido() const;
        std::string getTesteNomeInvalido() const;
};

//!getTesteValido da classe, ou seja, pega o atributo que passa a exceção
inline std::string TesteNome::getTesteNomeValido() const {
    return nomeValido;
}

//!getTesteInvalido da classe, ou seja, pega o atributo que reprova a exceção
inline std::string TesteNome::getTesteNomeInvalido() const {
    return nomeInvalido;
}

//!Classe utilizada para testar o dominio Matricula
class TesteMatricula
{
    private:
        //!atributos utilizados para armazenar dados validos ou invalidos
        std::string matriculaValida, matriculaInvalida;
    public:
        //!setup da classe
        TesteMatricula() {
            matriculaValida = "12345";
            matriculaInvalida = "123456";
        }
        //!tearDown da classe
        virtual ~TesteMatricula(){}
        std::string getTesteMatriculaValida() const;
        std::string getTesteMatriculaInvalida() const;
};

//!getTesteValido da classe, ou seja, pega o atributo que passa a exceção
inline std::string TesteMatricula::getTesteMatriculaValida() const {
    return matriculaValida;
}

//!getTesteInvalido da classe, ou seja, pega o atributo que reprova a exceção
inline std::string TesteMatricula::getTesteMatriculaInvalida() const {
    return matriculaInvalida;
}

//!Classe utilizada para testar o dominio Senha
class TesteSenha
{
    private:
        //!atributos utilizados para armazenar dados validos ou invalidos
        std::string senhaValida, senhaInvalida;
    public:
        //!setup da classe
        TesteSenha() {
            senhaValida = "123456";
            senhaInvalida = "12345";
        }
        //!tearDown da classe
        virtual ~TesteSenha(){}
        std::string getTesteSenhaValida() const;
        std::string getTesteSenhaInvalida() const;
};

//!getTesteValido da classe, ou seja, pega o atributo que passa a exceção
inline std::string TesteSenha::getTesteSenhaValida() const {
    return senhaValida;
}

//!getTesteInvalido da classe, ou seja, pega o atributo que reprova a exceção
inline std::string TesteSenha::getTesteSenhaInvalida() const {
    return senhaInvalida;
}

//!Classe utilizada para testar o dominio NumeroConta
class TesteNumeroConta
{
    private:
        //!atributos utilizados para armazenar dados validos ou invalidos
        std::string numero_contaValida, numero_contaInvalida;
    public:
        //!setup da classe
        TesteNumeroConta() {
            numero_contaValida = "1234";
            numero_contaInvalida = "12345";
        }
        //!tearDown da classe
        virtual ~TesteNumeroConta(){}
        std::string getTesteNumeroContaValida() const;
        std::string getTesteNumeroContaInvalida() const;
};

//!getTesteValido da classe, ou seja, pega o atributo que passa a exceção
inline std::string TesteNumeroConta::getTesteNumeroContaValida() const {
    return numero_contaValida;
}

//!getTesteInvalido da classe, ou seja, pega o atributo que reprova a exceção
inline std::string TesteNumeroConta::getTesteNumeroContaInvalida() const {
    return numero_contaInvalida;
}

//!Classe utilizada para testar o dominio NumeroPagamento
class TesteNumeroPagamento
{
    private:
        //!atributos utilizados para armazenar dados validos ou invalidos
        std::string numero_pagamentoValido, numero_pagamentoInvalido;
    public:
        //!setup da classe
        TesteNumeroPagamento() {
            numero_pagamentoValido = "123456";
            numero_pagamentoInvalido = "1234567";
        }
        //!tearDown da classe
        virtual ~TesteNumeroPagamento(){}
        std::string getTesteNumeroPagamentoValido() const;
        std::string getTesteNumeroPagamentoInvalido() const;
};

//!getTesteValido da classe, ou seja, pega o atributo que passa a exceção
inline std::string TesteNumeroPagamento::getTesteNumeroPagamentoValido() const {
    return numero_pagamentoValido;
}

//!getTesteInvalido da classe, ou seja, pega o atributo que reprova a exceção
inline std::string TesteNumeroPagamento::getTesteNumeroPagamentoInvalido() const {
    return numero_pagamentoInvalido;
}

//!Classe utilizada para testar o dominio TipoConta
class TesteTipoConta
{
    private:
        //!atributos utilizados para armazenar dados validos ou invalidos
        std::string tipo_contaValido, tipo_contaInvalido;
    public:
        //!setup da classe
        TesteTipoConta() {
            tipo_contaValido = "1";
            tipo_contaInvalido = "3";
        }
        //!tearDown da classe
        virtual ~TesteTipoConta(){}
        std::string getTesteTipoContaValido() const;
        std::string getTesteTipoContaInvalido() const;
};

//!getTesteValido da classe, ou seja, pega o atributo que passa a exceção
inline std::string TesteTipoConta::getTesteTipoContaValido() const {
    return tipo_contaValido;
}

//!getTesteInvalido da classe, ou seja, pega o atributo que reprova a exceção
inline std::string TesteTipoConta::getTesteTipoContaInvalido() const {
    return tipo_contaInvalido;
}

//!Classe utilizada para testar o dominio Data
class TesteData
{
    private:
        //!atributos utilizados para armazenar dados validos ou invalidos
        std::string dataValida, dataInvalida;
    public:
        //!setup da classe
        TesteData() {
            dataValida = "02-11-1987";
            dataInvalida = "13-02-2013";
        }
        //!tearDown da classe
        virtual ~TesteData(){}
        std::string getTesteDataValida() const;
        std::string getTesteDataInvalida() const;
};

//!getTesteValido da classe, ou seja, pega o atributo que passa a exceção
inline std::string TesteData::getTesteDataValida() const {
    return dataValida;
}

//!getTesteInvalido da classe, ou seja, pega o atributo que reprova a exceção
inline std::string TesteData::getTesteDataInvalida() const {
    return dataInvalida;
}

//!Classe utilizada para testar o dominio Dinheiro
class TesteDinheiro
{
    private:
        //!atributos utilizados para armazenar dados validos ou invalidos
        std::string dinheiroValido, dinheiroInvalido;
    public:
        //!setup da classe
        TesteDinheiro() {
            dinheiroValido = "3,00";
            dinheiroInvalido = "1";
        }
        //!tearDown da classe
        virtual ~TesteDinheiro(){}
        std::string getTesteDinheiroValido() const;
        std::string getTesteDinheiroInvalido() const;
};

//!getTesteValido da classe, ou seja, pega o atributo que passa a exceção
inline std::string TesteDinheiro::getTesteDinheiroValido() const {
    return dinheiroValido;
}

//!getTesteInvalido da classe, ou seja, pega o atributo que reprova a exceção
inline std::string TesteDinheiro::getTesteDinheiroInvalido() const {
    return dinheiroInvalido;
}

//!Classe utilizada para testar o dominio CodigoPagamento
class TesteCodigoPagamento
{
    private:
        //!atributos utilizados para armazenar dados validos ou invalidos
        std::string codigo_pagamentoValido, codigo_pagamentoInvalido;
    public:
        //!setup da classe
        TesteCodigoPagamento() {
            codigo_pagamentoValido = "1";
            codigo_pagamentoInvalido = "3";
        }
        //!tearDown da classe
        virtual ~TesteCodigoPagamento(){}
        std::string getTesteCodigoPagamentoValido() const;
        std::string getTesteCodigoPagamentoInvalido() const;
};

//!getTesteValido da classe, ou seja, pega o atributo que passa a exceção
inline std::string TesteCodigoPagamento::getTesteCodigoPagamentoValido() const {
    return codigo_pagamentoValido;
}

//!getTesteInvalido da classe, ou seja, pega o atributo que reprova a exceção
inline std::string TesteCodigoPagamento::getTesteCodigoPagamentoInvalido() const {
    return codigo_pagamentoInvalido;
}

//!São criados os objetos, pegos os dados de interesse e depois destruidos são os objetos.
inline void Teste::RunTestes() {
    TesteNome t;

    this->input = t.getTesteNomeValido();
    Nome(this->input);
    this->input = t.getTesteNomeInvalido();
    Nome(this->input);

    t.~TesteNome();

    TesteMatricula m;

    this->input = m.getTesteMatriculaValida();
    Matricula(this->input);
    this->input = m.getTesteMatriculaInvalida();
    Matricula(this->input);

    m.~TesteMatricula();

    TesteSenha s;

    this->input = s.getTesteSenhaValida();
    Senha(this->input);
    this->input = s.getTesteSenhaInvalida();
    Senha(this->input);

    s.~TesteSenha();

    TesteNumeroConta nc;

    this->input = nc.getTesteNumeroContaValida();
    NumeroConta(this->input);
    this->input = nc.getTesteNumeroContaInvalida();
    NumeroConta(this->input);

    nc.~TesteNumeroConta();

    TesteNumeroPagamento np;

    this->input = np.getTesteNumeroPagamentoValido();
    NumeroPagamento(this->input);
    this->input = np.getTesteNumeroPagamentoInvalido();
    NumeroPagamento(this->input);

    np.~TesteNumeroPagamento();

    TesteTipoConta tc;

    this->input = tc.getTesteTipoContaValido();
    TipoConta(this->input);
    this->input = tc.getTesteTipoContaInvalido();
    TipoConta(this->input);

    tc.~TesteTipoConta();

    TesteData dat;

    this->input = dat.getTesteDataValida();
    Data(this->input);
    this->input = dat.getTesteDataInvalida();
    Data(this->input);

    dat.~TesteData();

    TesteDinheiro din;

    this->input = din.getTesteDinheiroValido();
    Dinheiro(this->input);
    this->input = din.getTesteDinheiroInvalido();
    Dinheiro(this->input);

    din.~TesteDinheiro();

    TesteCodigoPagamento cp;

    this->input = cp.getTesteCodigoPagamentoValido();
    CodigoPagamento(this->input);
    this->input = cp.getTesteCodigoPagamentoInvalido();
    CodigoPagamento(this->input);

    cp.~TesteCodigoPagamento();

}

#endif //!TESTE_H
